Contract Testing

Contract Testing

Contract testing ensures that two services (e.g., a client and an API) agree on the format, structure, and behavior of their interactions. It is especially critical in microservices architectures where multiple services communicate with each other.

This section focuses on how testers implement contract testing to catch integration issues early and maintain service reliability.

---

What is Contract Testing?

• Definition: Contract testing verifies that the producer (API) and consumer (client) adhere to a shared contract.
• Why It Matters: Prevents integration failures caused by mismatched expectations (e.g., incorrect data formats, missing fields).

Tester Rule

Always validate both the producer and consumer sides of the contract to ensure seamless communication.

---

Key Concepts in Contract Testing

1️⃣ Producer and Consumer

• Producer: The service providing the API (e.g., REST endpoint).
• Consumer: The service consuming the API (e.g., frontend or another microservice).

2️⃣ Contract

• A formal agreement defining:
  • Request structure (e.g., headers, query params, body).
  • Response structure (e.g., status codes, JSON schema).

---

Tools for Contract Testing

1️⃣ Pact

• Popular framework for contract testing.
• Supports both producer and consumer tests.
• Generates a Pact file that defines the contract.

Code Snippet: Consumer Test with Pact

// Define Pact test for consumer
@Pact(provider = "UserService", consumer = "FrontendApp")
public RequestResponsePact createPact(PactDslWithProvider builder) {
    return builder
        .given("User exists")
        .uponReceiving("Get user details")
        .path("/users/101")
        .method("GET")
        .willRespondWith()
        .status(200)
        .body("{ \"id\": 101, \"name\": \"John\" }")
        .toPact();
}

@Test
@PactTestFor(pactMethod = "createPact")
void testGetUserDetails(MockServer mockServer) {
    // Call mock server
    Response response = given()
        .baseUri(mockServer.getUrl())
        .when()
        .get("/users/101");

    // Validate response
    response.then().statusCode(200);
}

2️⃣ OpenAPI/Swagger

• Use OpenAPI specifications to define contracts.
• Validate requests and responses against the schema.

Code Snippet: Validating Against OpenAPI

# Use tools like Swagger CLI to validate API responses
swagger-cli validate api-spec.yaml

---

Steps to Implement Contract Testing

Step 1: Define the Contract

• Collaborate with developers to define the expected request/response structure.
• Use tools like Pact or OpenAPI to document the contract.

Step 2: Write Consumer Tests

• Simulate the producer using mocks.
• Validate that the consumer sends correct requests and handles responses.

Example: Consumer Test

// Mock producer response
mockServer.stubFor(get(urlPathEqualTo("/users/101"))
    .willReturn(aResponse()
        .withStatus(200)
        .withBody("{ \"id\": 101, \"name\": \"John\" }")));

// Validate consumer behavior
Response response = given()
    .baseUri(mockServer.baseUrl())
    .when()
    .get("/users/101");

response.then().statusCode(200);

Step 3: Write Producer Tests

• Validate that the producer adheres to the contract.
• Use the Pact file generated by consumer tests.

Example: Producer Test

// Verify producer meets contract
@Provider("UserService")
@PactFolder("pacts")
class UserServiceTest {

    @TestTemplate
    @PactVerification("FrontendApp")
    void testGetUserDetails(PactVerificationContext context) {
        context.verifyInteraction();
    }
}

---

Benefits of Contract Testing

1. Early Detection: Catches integration issues before deployment.
2. Decoupled Testing: Allows independent testing of producers and consumers.
3. Improved Reliability: Ensures services communicate as expected.

---

Common Pitfalls ❌

• Ignoring contract updates when APIs change.
• Not validating both producer and consumer sides.
• Over-reliance on end-to-end tests instead of contract tests.

---

Interview-Ready Questions

Q: What is contract testing?
A: Contract testing ensures that the producer and consumer of an API agree on the format, structure, and behavior of their interactions.

Q: How does Pact work?
A: Pact generates a contract file from consumer tests and validates the producer against it.

---

Key Takeaways 🎯

• Contract testing prevents integration failures in microservices architectures.
• Use tools like Pact or OpenAPI to define and validate contracts.
• Write both consumer and producer tests to ensure adherence.
• Catch issues early by integrating contract tests into CI/CD pipelines.
• Avoid common pitfalls like ignoring contract updates or over-relying on end-to-end tests.